const inquirer = require("inquirer");
const chalk = require("chalk");
const ora = require("ora");
const fs = require("fs-extra");
const path = require("path");
const archiver = require("archiver");
const { getPrompts } = require("./prompts");
const feishuService = require("../services/feishu");
const generators = require("../generators");
const { createOutputDir, compressFolder } = require("../utils/file");
const { startServer, stopServer } = require("../services/server");

class I18nCLI {
  constructor() {
    this.config = {
      auth: {},
      table: {},
      generation: {},
    };
    this.tableData = [];
    this.availableLanguages = [];
    this.internalServer = null;
    this.packageConfig = null; // 存储从package.json读取的配置
  }

  // 读取package.json中的lang配置
  async loadPackageConfig() {
    try {
      const packagePath = path.join(process.cwd(), "package.json");
      if (await fs.pathExists(packagePath)) {
        const packageData = await fs.readJson(packagePath);
        if (packageData.lang) {
          this.packageConfig = packageData.lang;
          console.log(chalk.blue("📋 发现package.json中的lang配置"));
          console.log(
            chalk.gray(
              `配置内容: ${JSON.stringify(this.packageConfig, null, 2)}`
            )
          );
          return true;
        }
      }
      return false;
    } catch (error) {
      console.log(chalk.yellow(`读取package.json配置失败: ${error.message}`));
      return false;
    }
  }

  // 验证package.json配置的完整性
  validatePackageConfig() {
    if (!this.packageConfig) return false;

    const required = ["type", "AppID", "AppSecret"];
    for (const field of required) {
      if (!this.packageConfig[field]) {
        console.log(chalk.yellow(`配置缺少必需字段: ${field}`));
        return false;
      }
    }

    // 根据类型验证额外字段
    if (this.packageConfig.type === "sheets") {
      if (!this.packageConfig.spreadsheetToken) {
        console.log(chalk.yellow(`sheets类型配置缺少spreadsheetToken字段`));
        return false;
      }
    } else if (this.packageConfig.type === "wiki") {
      if (!this.packageConfig.WikiUrl) {
        console.log(chalk.yellow(`wiki类型配置缺少WikiUrl字段`));
        return false;
      }
    }

    return true;
  }

  // 使用package.json配置进行认证
  async authenticateFromConfig() {
    console.log(chalk.cyan("📝 使用配置文件进行飞书认证"));

    const spinner = ora("正在验证飞书认证信息...").start();
    try {
      await feishuService.authenticate(
        this.packageConfig.AppID,
        this.packageConfig.AppSecret
      );
      spinner.succeed("飞书认证验证成功");

      // 设置认证配置
      this.config.auth = {
        appKey: this.packageConfig.AppID,
        appSecret: this.packageConfig.AppSecret,
      };

      // 额外验证：检查认证状态
      if (!feishuService.checkAuthStatus()) {
        throw new Error("认证后状态检查失败");
      }
    } catch (error) {
      spinner.fail("飞书认证验证失败");
      console.error(chalk.red("配置文件认证失败:"), error.message);
      throw error;
    }
  }

  // 使用package.json配置设置表格信息
  async loadTableInfoFromConfig() {
    console.log(chalk.cyan("📊 使用配置文件设置表格信息"));

    if (this.packageConfig.type === "sheets") {
      // 解析sheetId，支持多个工作表ID用|分割
      const sheetIds = this.packageConfig.sheetId
        ? this.packageConfig.sheetId
            .split("|")
            .map((id) => id.trim())
            .filter((id) => id)
        : [];

      this.config.table = {
        type: "sheets",
        spreadsheetToken: this.packageConfig.spreadsheetToken,
        sheetIdentifiers: sheetIds.length > 0 ? sheetIds : ["第一个工作表"],
        isMultiSheet: sheetIds.length > 1,
      };

      console.log(chalk.blue(`表格类型: 飞书表格`));
      console.log(
        chalk.gray(`表格Token: ${this.packageConfig.spreadsheetToken}`)
      );

      if (sheetIds.length > 1) {
        console.log(
          chalk.blue(`🔗 多工作表合并模式 (${sheetIds.length}个工作表)`)
        );
        console.log(chalk.gray(`工作表顺序: ${sheetIds.join(" → ")}`));
        console.log(chalk.yellow(`注意: 后续工作表的相同key会覆盖前面的数据`));
      } else {
        console.log(
          chalk.gray(`工作表ID: ${sheetIds[0] || "将自动选择第一个工作表"}`)
        );
      }
    } else if (this.packageConfig.type === "wiki") {
      // 解析wiki URL
      const { docToken, sheetId } = feishuService.parseWikiUrl(
        this.packageConfig.WikiUrl
      );
      this.config.table = {
        type: "wiki",
        wikiUrl: this.packageConfig.WikiUrl,
        spreadsheetToken: docToken,
        sheetIdentifiers: [sheetId],
        isMultiSheet: false,
      };

      console.log(chalk.blue(`表格类型: 知识库表格`));
      console.log(chalk.gray(`Wiki URL: ${this.packageConfig.WikiUrl}`));
    }
  }

  async start() {
    console.log(chalk.blue("🚀 欢迎使用 i18n-CLI 多语言文件生成工具!\n"));

    try {
      // 自动启动服务
      await this.startInternalServer();

      // 检查是否有package.json配置
      const hasConfig = await this.loadPackageConfig();

      if (hasConfig && this.validatePackageConfig()) {
        console.log(chalk.green("✅ 使用package.json配置文件模式\n"));

        // 步骤1: 使用配置文件进行认证
        await this.authenticateFromConfig();

        // 步骤2: 使用配置文件设置表格信息
        await this.loadTableInfoFromConfig();

        // 步骤3: 获取表格数据
        await this.fetchTableDataFromConfig();
      } else {
        if (hasConfig) {
          console.log(
            chalk.yellow("⚠️  package.json配置不完整，回退到交互式模式\n")
          );
        } else {
          console.log(chalk.blue("💬 使用交互式配置模式\n"));
        }

        // 交互式模式
        // 步骤1: 获取飞书认证信息
        await this.getFeishuAuth();

        // 步骤2: 获取表格信息
        await this.getTableInfo();

        // 步骤3: 获取表格数据并解析可用语言
        await this.fetchTableData();
      }

      // 步骤4: 选择配置（总是交互式，除非也配置了生成选项）
      await this.getGenerationConfig();

      // 步骤5: 生成多语言文件
      await this.generateFiles();

      console.log(chalk.green("\n✅ 多语言文件生成完成!"));
    } catch (error) {
      console.error(chalk.red("\n❌ 生成过程中出现错误:"), error.message);
      throw error;
    } finally {
      // 自动停止服务
      await this.stopInternalServer();
    }
  }

  async getFeishuAuth() {
    console.log(chalk.cyan("📝 第一步: 飞书应用认证"));
    console.log(chalk.gray("请输入您的飞书应用凭证信息\n"));

    const authQuestions = [
      {
        type: "input",
        name: "appKey",
        message: "请输入飞书应用的 App Key:",
        validate: (input) => input.trim() !== "" || "App Key 不能为空",
      },
      {
        type: "password",
        name: "appSecret",
        message: "请输入飞书应用的 App Secret:",
        mask: "*",
        validate: (input) => input.trim() !== "" || "App Secret 不能为空",
      },
    ];

    const authAnswers = await inquirer.prompt(authQuestions);
    this.config.auth = authAnswers;

    // 验证认证信息
    const spinner = ora("正在验证飞书认证信息...").start();
    try {
      await feishuService.authenticate(
        authAnswers.appKey,
        authAnswers.appSecret
      );
      spinner.succeed("飞书认证验证成功");

      // 额外验证：检查认证状态
      if (!feishuService.checkAuthStatus()) {
        throw new Error("认证后状态检查失败");
      }
    } catch (error) {
      spinner.fail("飞书认证验证失败");

      // 提供详细的错误诊断
      await this.showAuthDiagnostics(error, authAnswers);

      throw new Error("认证信息无效，请检查 App Key 和 App Secret");
    }
  }

  // 认证诊断工具
  async showAuthDiagnostics(error, authInfo) {
    console.log(chalk.red("\n🔍 认证错误诊断:"));
    console.log(chalk.red(`错误信息: ${error.message}\n`));

    console.log(chalk.yellow("📋 检查清单:"));
    console.log(chalk.yellow("1. App Key格式检查:"));
    console.log(
      chalk.gray(`   - 当前长度: ${authInfo.appKey?.length || 0} 字符`)
    );
    console.log(chalk.gray(`   - 预期格式: cli_a开头的字符串`));
    console.log(
      chalk.gray(
        `   - 您的App Key前缀: ${authInfo.appKey?.substring(0, 6) || "无"}`
      )
    );

    console.log(chalk.yellow("\n2. App Secret格式检查:"));
    console.log(
      chalk.gray(`   - 当前长度: ${authInfo.appSecret?.length || 0} 字符`)
    );
    console.log(chalk.gray(`   - 预期长度: 32个字符`));

    console.log(chalk.yellow("\n3. 常见问题排查:"));
    console.log(
      chalk.gray("   - 确保在飞书开发者后台正确获取App Key和App Secret")
    );
    console.log(chalk.gray("   - 检查应用是否已启用"));
    console.log(chalk.gray("   - 确认应用权限包含'读取云文档'"));
    console.log(chalk.gray("   - 检查网络连接是否正常"));

    if (error.message.includes("99991661")) {
      console.log(chalk.red("\n⚠️  特别说明: 错误代码99991661"));
      console.log(chalk.yellow("这通常表示:"));
      console.log(chalk.yellow("- App Key或App Secret不正确"));
      console.log(chalk.yellow("- 应用状态异常（可能被禁用）"));
      console.log(chalk.yellow("- 网络请求中断"));
    }

    console.log(chalk.blue("\n💡 建议操作:"));
    console.log(chalk.blue("1. 重新从飞书开发者后台复制App Key和App Secret"));
    console.log(chalk.blue("2. 确认应用状态为'已发布'或'开发中'"));
    console.log(chalk.blue("3. 检查应用权限配置"));
  }

  async getTableInfo() {
    console.log(chalk.cyan("\n📊 第二步: 表格信息"));
    console.log(chalk.gray("请选择要获取的飞书表格类型\n"));

    // 第一步：让用户选择表格类型
    const typeQuestion = {
      type: "list",
      name: "tableType",
      message: "请选择表格类型:",
      choices: [
        {
          name: "📊 飞书表格 (Sheets) - 独立的在线表格",
          value: "sheets",
          short: "飞书表格",
        },
        {
          name: "📖 飞书知识库表格 (Wiki) - 知识库文档中的表格",
          value: "wiki",
          short: "知识库表格",
        },
      ],
    };

    const typeAnswer = await inquirer.prompt(typeQuestion);
    const selectedType = typeAnswer.tableType;

    console.log(
      chalk.blue(
        `\n✅ 已选择: ${selectedType === "sheets" ? "飞书表格" : "知识库表格"}`
      )
    );

    // 根据选择的类型进行不同处理
    if (selectedType === "sheets") {
      await this.handleSheetsFlow();
    } else {
      await this.handleWikiFlow();
    }
  }

  // 处理飞书表格流程
  async handleSheetsFlow() {
    console.log(chalk.blue("\n📋 飞书表格信息获取:"));
    console.log(chalk.gray("支持的输入格式:"));
    console.log(
      chalk.gray("1. 完整URL: https://xxx.feishu.cn/sheets/shtxxx/xxx")
    );
    console.log(chalk.gray("2. 表格ID: shtcnmBA***"));
    console.log(
      chalk.gray(
        "示例: https://jcndu9wigk06.feishu.cn/sheets/Yff8sHeI4hW4RqtwJXDcj3uwn1g\n"
      )
    );

    const urlQuestion = {
      type: "input",
      name: "urlOrToken",
      message: "请输入飞书表格URL或表格ID:",
      validate: (input) => input.trim() !== "" || "输入不能为空",
    };

    const urlAnswer = await inquirer.prompt(urlQuestion);
    const input = urlAnswer.urlOrToken.trim();

    // 检测输入类型
    if (input.startsWith("http")) {
      // 是URL，验证是否为sheets URL
      if (!input.includes("/sheets/")) {
        throw new Error("请输入正确的飞书表格URL（包含/sheets/）");
      }
      await this.handleSheetsUrl(input);
    } else {
      // 是表格ID
      await this.handleSpreadsheetToken(input);
    }
  }

  // 处理知识库表格流程
  async handleWikiFlow() {
    console.log(chalk.blue("\n📋 知识库表格信息获取:"));
    console.log(chalk.gray("请输入完整的知识库表格URL"));
    console.log(
      chalk.gray("格式: https://xxx.feishu.cn/wiki/文档ID?sheet=工作表ID")
    );
    console.log(
      chalk.gray(
        "示例: https://jcndu9wigk06.feishu.cn/wiki/HPNxwAkNHigttekbCJpcxgeZnoc?sheet=a8a0d1\n"
      )
    );

    const urlQuestion = {
      type: "input",
      name: "wikiUrl",
      message: "请输入知识库表格URL:",
      validate: (input) => {
        const trimmed = input.trim();
        if (!trimmed) return "输入不能为空";
        if (!trimmed.startsWith("http")) return "请输入完整的URL";
        if (!trimmed.includes("/wiki/"))
          return "请输入正确的知识库URL（包含/wiki/）";
        if (!trimmed.includes("?sheet=")) return "URL中必须包含?sheet=参数";
        return true;
      },
    };

    const urlAnswer = await inquirer.prompt(urlQuestion);
    await this.handleWikiUrl(urlAnswer.wikiUrl.trim());
  }

  // 处理知识库URL
  async handleWikiUrl(wikiUrl) {
    const spinner = ora("正在解析知识库URL...").start();
    try {
      const { docToken, sheetId } = feishuService.parseWikiUrl(wikiUrl);
      spinner.succeed(`知识库URL解析成功`);

      console.log(chalk.gray(`文档ID: ${docToken}`));
      console.log(chalk.gray(`工作表ID: ${sheetId}`));

      // 尝试获取数据
      const dataSpinner = ora("正在获取知识库表格数据...").start();
      try {
        const data = await feishuService.getWikiTableData(wikiUrl);
        dataSpinner.succeed("知识库表格数据获取成功");

        this.config.table = {
          type: "wiki",
          wikiUrl: wikiUrl,
          spreadsheetToken: docToken,
          sheetIdentifiers: [sheetId],
          isMultiSheet: false,
        };

        // 直接设置表格数据，跳过后续的fetchTableData步骤
        this.tableData = data;
      } catch (error) {
        dataSpinner.fail("知识库表格数据获取失败");
        console.error(chalk.red("错误详情:"), error.message);
        console.log(chalk.yellow("\n💡 建议:"));
        console.log(chalk.yellow("1. 检查应用是否有访问该文档的权限"));
        console.log(chalk.yellow("2. 或者将数据复制到标准的飞书表格中"));
        throw error;
      }
    } catch (error) {
      spinner.fail("知识库URL解析失败");
      throw error;
    }
  }

  // 处理表格URL
  async handleSheetsUrl(sheetsUrl) {
    try {
      const url = new URL(sheetsUrl);
      const pathMatch = url.pathname.match(/\/sheets\/([a-zA-Z0-9]+)/);
      if (!pathMatch) {
        throw new Error("无法从表格URL中解析出表格ID");
      }
      const spreadsheetToken = pathMatch[1];

      await this.handleSpreadsheetToken(spreadsheetToken);
    } catch (error) {
      throw new Error(`表格URL解析失败: ${error.message}`);
    }
  }

  // 处理表格ID（原有逻辑）
  async handleSpreadsheetToken(spreadsheetToken) {
    // 验证表格ID是否有效
    const spinner = ora("正在验证表格ID...").start();
    try {
      const sheets = await feishuService.getSheets(spreadsheetToken);
      spinner.succeed(`表格验证成功，找到 ${sheets.length} 个工作表`);

      // 显示可用的工作表
      console.log(chalk.gray("\n可用的工作表:"));
      sheets.forEach((sheet, index) => {
        console.log(
          chalk.gray(`  ${index + 1}. ${sheet.title} (ID: ${sheet.sheet_id})`)
        );
      });

      // 询问用户选择哪个工作表
      const sheetQuestion = {
        type: "input",
        name: "sheetIdentifier",
        message: "\n请输入 Sheet 名称或 Sheet ID:",
        validate: (input) => input.trim() !== "" || "Sheet信息不能为空",
      };

      const sheetAnswer = await inquirer.prompt(sheetQuestion);

      this.config.table = {
        type: "sheets",
        spreadsheetToken: spreadsheetToken,
        sheetIdentifier: sheetAnswer.sheetIdentifier,
      };
    } catch (error) {
      spinner.fail("表格ID验证失败");
      console.error(chalk.red("错误详情:"), error.message);
      console.log(chalk.yellow("\n请检查:"));
      console.log(chalk.yellow("1. 表格ID是否正确"));
      console.log(chalk.yellow("2. 应用是否有访问该表格的权限"));
      console.log(chalk.yellow("3. 表格是否存在且未被删除"));
      throw new Error("表格ID无效或无权限访问");
    }
  }

  async fetchTableData() {
    // 如果是知识库数据，数据已经在handleWikiUrl中获取了
    if (this.config.table.type === "wiki" && this.tableData) {
      console.log(chalk.blue("\n✅ 使用已获取的知识库表格数据"));

      // 解析可用语言（从表格第一行获取）
      if (this.tableData.length > 0) {
        const headers = this.tableData[0];
        // 第一列是key，其他列是语言
        this.availableLanguages = headers
          .slice(1)
          .filter((lang) => lang && lang.trim());
      }

      if (this.availableLanguages.length === 0) {
        throw new Error("未找到可用的语言列，请检查表格格式");
      }

      console.log(
        chalk.green(
          `表格数据验证成功，找到 ${
            this.availableLanguages.length
          } 种语言: ${this.availableLanguages.join(", ")}`
        )
      );
      return;
    }

    // 常规表格数据获取
    const spinner = ora("正在获取表格数据...").start();

    try {
      // 获取表格数据
      const data = await feishuService.getSheetData(
        this.config.table.spreadsheetToken,
        this.config.table.sheetIdentifier
      );

      this.tableData = data;

      // 解析可用语言（从表格第一行获取）
      if (data.length > 0) {
        const headers = data[0];
        // 第一列是key，其他列是语言
        this.availableLanguages = headers
          .slice(1)
          .filter((lang) => lang && lang.trim());
      }

      if (this.availableLanguages.length === 0) {
        throw new Error("未找到可用的语言列，请检查表格格式");
      }

      spinner.succeed(
        `表格数据获取成功，找到 ${
          this.availableLanguages.length
        } 种语言: ${this.availableLanguages.join(", ")}`
      );
    } catch (error) {
      spinner.fail("获取表格数据失败");
      throw error;
    }
  }

  async getGenerationConfig() {
    console.log(chalk.cyan("\n⚙️  第三步: 生成配置"));
    console.log(chalk.gray("请选择要生成的配置\n"));

    const configQuestions = [
      {
        type: "list",
        name: "platform",
        message: "请选择目标平台:",
        choices: [
          { name: "🌐 Web", value: "web" },
          { name: "📱 iOS", value: "ios" },
          { name: "🤖 Android", value: "android" },
          { name: "🖥️  React Native", value: "rn" },
          { name: "⚡ Flutter", value: "flutter" },
        ],
      },
      {
        type: "checkbox",
        name: "languages",
        message: "请选择要生成的语言:",
        choices: this.availableLanguages.map((lang) => ({
          name: lang,
          value: lang,
          checked: true,
        })),
        validate: (input) => input.length > 0 || "请至少选择一种语言",
      },
      {
        type: "checkbox",
        name: "formats",
        message: "请选择文件格式:",
        choices: (answers) => {
          const platformFormats = {
            web: [{ name: "JSON", value: "json", checked: true }],
            ios: [
              { name: "Strings", value: "strings", checked: true },
              { name: "Localizable.stringsdict", value: "stringsdict" },
            ],
            android: [{ name: "XML", value: "xml", checked: true }],
            rn: [{ name: "JSON", value: "json", checked: true }],
            flutter: [
              { name: "ARB", value: "arb", checked: true },
              { name: "JSON", value: "json" },
            ],
          };
          return platformFormats[answers.platform] || platformFormats.web;
        },
        validate: (input) => input.length > 0 || "请至少选择一种格式",
      },
    ];

    const configAnswers = await inquirer.prompt(configQuestions);
    this.config.generation = configAnswers;
  }

  async generateFiles() {
    const spinner = ora("正在生成多语言文件...").start();

    try {
      const { platform, languages, formats } = this.config.generation;

      // 创建输出目录
      const folderName = `${platform}.${languages.join(",")}.${formats.join(
        ","
      )}`;
      const outputDir = await createOutputDir(folderName);

      // 转换表格数据为key-value格式
      const i18nData = this.transformTableData();

      // 为每种语言和格式组合生成文件
      const generatedFiles = [];

      for (const language of languages) {
        for (const format of formats) {
          const fileName = `${language}.${format}`;
          const filePath = path.join(outputDir, fileName);

          // 获取该语言的数据
          const langData = i18nData[language] || {};

          // 根据格式生成文件
          await generators.generate(format, langData, filePath, platform);
          generatedFiles.push(fileName);
        }
      }

      spinner.text = "正在压缩文件...";

      // 压缩文件夹
      const compressedFile = await compressFolder(outputDir, folderName);

      spinner.succeed(
        `文件生成完成! 已生成 ${generatedFiles.length} 个文件并压缩到: ${compressedFile}`
      );

      console.log(chalk.green("\n📁 生成的文件:"));
      generatedFiles.forEach((file) => {
        console.log(chalk.gray(`  - ${file}`));
      });
    } catch (error) {
      spinner.fail("文件生成失败");
      throw error;
    }
  }

  transformTableData() {
    const result = {};

    if (this.tableData.length === 0) return result;

    const headers = this.tableData[0]; // 第一行是标题
    const dataRows = this.tableData.slice(1); // 从第二行开始是数据

    // 初始化各语言的数据对象
    this.availableLanguages.forEach((lang) => {
      result[lang] = {};
    });

    // 处理每一行数据
    dataRows.forEach((row) => {
      const key = row[0]; // 第一列是key
      const keyStr = String(key || "").trim();
      if (!keyStr) return; // 跳过空key

      // 处理每种语言的值
      headers.slice(1).forEach((lang, index) => {
        const langStr = String(lang || "").trim();
        if (langStr && result[langStr]) {
          const value = row[index + 1] || ""; // +1 因为第一列是key
          const valueStr = String(value).trim();
          result[langStr][keyStr] = valueStr;
        }
      });
    });

    return result;
  }

  async startInternalServer() {
    const spinner = ora("正在启动内部API服务...").start();

    try {
      // 找一个可用端口
      const port = await this.findAvailablePort(3000);
      this.internalServer = await startServer(port);

      spinner.succeed(`内部API服务已启动 (端口: ${port})`);
      console.log(chalk.gray(`🔗 服务地址: http://localhost:${port}\n`));
    } catch (error) {
      spinner.fail("内部API服务启动失败");
      console.log(chalk.yellow("⚠️  将继续使用直接API调用模式\n"));
      // 不抛出错误，继续执行
    }
  }

  async stopInternalServer() {
    if (this.internalServer) {
      const spinner = ora("正在停止内部API服务...").start();

      try {
        await stopServer(this.internalServer);
        spinner.succeed("内部API服务已停止");
        this.internalServer = null;
      } catch (error) {
        spinner.warn("停止服务时出现警告");
        console.log(chalk.yellow(`⚠️  ${error.message}`));
      }
    }
  }

  async findAvailablePort(startPort) {
    const net = require("net");

    return new Promise((resolve, reject) => {
      const server = net.createServer();

      server.listen(startPort, () => {
        const port = server.address().port;
        server.close(() => {
          resolve(port);
        });
      });

      server.on("error", (err) => {
        if (err.code === "EADDRINUSE") {
          // 端口被占用，尝试下一个端口
          resolve(this.findAvailablePort(startPort + 1));
        } else {
          reject(err);
        }
      });
    });
  }

  // 从配置文件获取表格数据
  async fetchTableDataFromConfig() {
    if (this.packageConfig.type === "sheets") {
      // 处理飞书表格
      await this.fetchSheetsDataFromConfig();
    } else if (this.packageConfig.type === "wiki") {
      // 处理知识库表格
      await this.fetchWikiDataFromConfig();
    }
  }

  // 从配置获取飞书表格数据
  async fetchSheetsDataFromConfig() {
    const spinner = ora("正在获取表格数据...").start();

    try {
      // 首先获取所有工作表列表
      const sheets = await feishuService.getSheets(
        this.packageConfig.spreadsheetToken
      );
      if (sheets.length === 0) {
        throw new Error("表格中没有找到任何工作表");
      }

      // 显示所有可用的工作表
      console.log(chalk.blue(`\n发现 ${sheets.length} 个工作表:`));
      sheets.forEach((sheet, index) => {
        console.log(
          chalk.gray(`  ${index + 1}. ${sheet.title} (ID: ${sheet.sheet_id})`)
        );
      });

      const sheetIdentifiers = this.config.table.sheetIdentifiers;
      const isMultiSheet = this.config.table.isMultiSheet;

      if (isMultiSheet) {
        // 多工作表合并模式
        await this.mergeMultipleSheets(sheets, sheetIdentifiers, spinner);
      } else {
        // 单工作表模式
        await this.fetchSingleSheet(sheets, sheetIdentifiers[0], spinner);
      }
    } catch (error) {
      spinner.fail("获取表格数据失败");
      console.error(chalk.red("详细错误:"), error.message);
      if (error.response) {
        console.error(chalk.red("HTTP状态:"), error.response.status);
        console.error(
          chalk.red("响应数据:"),
          JSON.stringify(error.response.data, null, 2)
        );
      }
      throw error;
    }
  }

  // 处理单个工作表
  async fetchSingleSheet(sheets, sheetIdentifier, spinner) {
    // 确定要使用的工作表
    let targetSheet = null;

    if (sheetIdentifier && sheetIdentifier !== "第一个工作表") {
      // 先尝试按ID匹配
      targetSheet = sheets.find((s) => s.sheet_id === sheetIdentifier);
      // 如果没找到，尝试按名称匹配
      if (!targetSheet) {
        targetSheet = sheets.find((s) => s.title === sheetIdentifier);
      }

      if (!targetSheet) {
        console.log(
          chalk.yellow(`\n⚠️  未找到指定的工作表: ${sheetIdentifier}`)
        );
        console.log(chalk.yellow("将使用第一个工作表"));
        targetSheet = sheets[0];
      } else {
        console.log(
          chalk.green(
            `\n✅ 找到匹配的工作表: ${targetSheet.title} (${targetSheet.sheet_id})`
          )
        );
      }
    } else {
      targetSheet = sheets[0];
      console.log(
        chalk.blue(
          `\n自动选择第一个工作表: ${targetSheet.title} (${targetSheet.sheet_id})`
        )
      );
    }

    // 获取工作表数据
    const data = await this.getSheetDataDirect(targetSheet);
    this.tableData = data;
    this.parseAvailableLanguages();

    spinner.succeed(
      `表格数据获取成功，使用工作表: ${targetSheet.title}，找到 ${
        this.availableLanguages.length
      } 种语言: ${this.availableLanguages.join(", ")}`
    );
  }

  // 处理多个工作表合并
  async mergeMultipleSheets(sheets, sheetIdentifiers, spinner) {
    console.log(chalk.blue(`\n开始多工作表数据合并...`));

    let mergedData = [];
    let mergedDataMap = new Map(); // 用于跟踪key的来源和检测覆盖
    let allLanguages = new Set();

    for (let i = 0; i < sheetIdentifiers.length; i++) {
      const sheetId = sheetIdentifiers[i];

      // 查找工作表
      let targetSheet = sheets.find((s) => s.sheet_id === sheetId);
      if (!targetSheet) {
        targetSheet = sheets.find((s) => s.title === sheetId);
      }

      if (!targetSheet) {
        console.log(chalk.yellow(`⚠️  未找到工作表: ${sheetId}，跳过`));
        continue;
      }

      console.log(
        chalk.cyan(
          `📖 正在读取工作表 ${i + 1}: ${targetSheet.title} (${
            targetSheet.sheet_id
          })`
        )
      );

      try {
        const sheetData = await this.getSheetDataDirect(targetSheet);

        if (sheetData.length === 0) {
          console.log(
            chalk.yellow(`⚠️  工作表 ${targetSheet.title} 没有数据，跳过`)
          );
          continue;
        }

        // 处理表头（第一行）
        if (i === 0) {
          // 第一个工作表，初始化表头
          mergedData.push(sheetData[0]);
          // 记录语言列
          sheetData[0].slice(1).forEach((lang) => {
            if (lang && lang.trim()) {
              allLanguages.add(lang.trim());
            }
          });
        } else {
          // 后续工作表，检查表头兼容性
          const currentHeaders = sheetData[0];
          const baseHeaders = mergedData[0];

          // 合并新的语言列
          currentHeaders.slice(1).forEach((lang) => {
            if (lang && lang.trim()) {
              allLanguages.add(lang.trim());
              if (!baseHeaders.includes(lang)) {
                baseHeaders.push(lang);
              }
            }
          });

          // 更新合并后的表头
          mergedData[0] = baseHeaders;
        }

        // 处理数据行（从第二行开始）
        for (let rowIndex = 1; rowIndex < sheetData.length; rowIndex++) {
          const row = sheetData[rowIndex];
          const key = row[0];

          if (!key || !key.trim()) {
            continue; // 跳过空key
          }

          // 检查是否存在覆盖
          if (mergedDataMap.has(key)) {
            const existingInfo = mergedDataMap.get(key);
            console.log(
              chalk.red(
                `🔄 覆盖操作: 《${targetSheet.title} - ${key}》覆盖 《${existingInfo.sheetName} - ${key}》`
              )
            );
          }

          // 构建新行数据，按照合并后的表头顺序
          const currentHeaders = sheetData[0];
          const mergedHeaders = mergedData[0];
          const newRow = new Array(mergedHeaders.length).fill("");
          newRow[0] = key; // 设置key

          // 填充数据
          for (let colIndex = 1; colIndex < currentHeaders.length; colIndex++) {
            const lang = currentHeaders[colIndex];
            const value = row[colIndex] || "";
            const targetColIndex = mergedHeaders.indexOf(lang);
            if (targetColIndex > 0) {
              newRow[targetColIndex] = value;
            }
          }

          // 查找是否已存在该key的行
          let existingRowIndex = -1;
          for (let j = 1; j < mergedData.length; j++) {
            if (mergedData[j][0] === key) {
              existingRowIndex = j;
              break;
            }
          }

          if (existingRowIndex > 0) {
            // 覆盖现有行，但保留其他列的数据
            for (let colIndex = 1; colIndex < newRow.length; colIndex++) {
              if (newRow[colIndex]) {
                // 只覆盖非空值
                mergedData[existingRowIndex][colIndex] = newRow[colIndex];
              }
            }
          } else {
            // 添加新行
            mergedData.push(newRow);
          }

          // 更新key映射
          mergedDataMap.set(key, {
            sheetName: targetSheet.title,
            sheetId: targetSheet.sheet_id,
          });
        }

        console.log(
          chalk.green(
            `✅ 工作表 ${targetSheet.title} 处理完成，当前总计 ${
              mergedData.length - 1
            } 个key`
          )
        );
      } catch (error) {
        console.log(
          chalk.red(`❌ 工作表 ${targetSheet.title} 处理失败: ${error.message}`)
        );
      }
    }

    this.tableData = mergedData;
    this.parseAvailableLanguages();

    const totalKeys = mergedData.length - 1;
    const languageCount = this.availableLanguages.length;

    spinner.succeed(
      `多工作表合并完成！总计 ${totalKeys} 个key，${languageCount} 种语言: ${this.availableLanguages.join(
        ", "
      )}`
    );
  }

  // 直接获取工作表数据的辅助方法
  async getSheetDataDirect(targetSheet) {
    // 暂时修改feishu服务的findSheetId方法，使其直接返回我们已知的sheet ID
    const originalFindSheetId = feishuService.findSheetId;
    feishuService.findSheetId = async (spreadsheetToken, sheetIdentifier) => {
      return targetSheet.sheet_id;
    };

    try {
      const data = await feishuService.getSheetData(
        this.packageConfig.spreadsheetToken,
        targetSheet.sheet_id
      );
      return data;
    } finally {
      // 恢复原来的方法
      feishuService.findSheetId = originalFindSheetId;
    }
  }

  // 从配置获取知识库表格数据
  async fetchWikiDataFromConfig() {
    const spinner = ora("正在获取知识库表格数据...").start();

    try {
      const data = await feishuService.getWikiTableData(
        this.packageConfig.WikiUrl
      );
      this.tableData = data;
      this.parseAvailableLanguages();

      spinner.succeed(
        `知识库表格数据获取成功，找到 ${
          this.availableLanguages.length
        } 种语言: ${this.availableLanguages.join(", ")}`
      );
    } catch (error) {
      spinner.fail("获取知识库表格数据失败");
      throw error;
    }
  }

  // 解析可用语言
  parseAvailableLanguages() {
    if (this.tableData.length > 0) {
      const headers = this.tableData[0];
      // 第一列是key，其他列是语言
      this.availableLanguages = headers
        .slice(1)
        .filter((lang) => lang && lang.trim());
    }

    if (this.availableLanguages.length === 0) {
      throw new Error("未找到可用的语言列，请检查表格格式");
    }
  }
}

module.exports = {
  start: async () => {
    const cli = new I18nCLI();
    await cli.start();
  },
};
